home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / MUSIC / @FALCON / MP2_07 / SRC / GEM / MP2EVENT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-24  |  18.0 KB  |  730 lines
  1. #include <tos.h>
  2. #include <vdi.h>
  3. #include <aes.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6.  
  7. #include "mp2audio.h"
  8. #include "mp2wind.h"
  9.  
  10. /* Functions in this module */
  11. void main_event_loop(void);
  12. void bg_event_loop(void);
  13. void fg_event_loop(void);
  14. int ev2_loop(WINDFORM *wind, int mx, int my);
  15. void toggle_object(WINDFORM *wind,int obj_id);
  16. void fg_init(WINDFORM *wind);
  17. int find_windform(int whandle);
  18. int handle_message(int pipe[8]);
  19. void update_objects(WINDFORM *wind,int obj_id,int depth, int pipe[8]);
  20. int do_formstuff(int obj_id);
  21. void update_time(void);
  22. long reset_timerc(void);
  23. long read_timerc(void);
  24. long set_timerc(void);
  25.  
  26. /* global variable */
  27. int fgbg,closed_acc=0,file_was_open,looping=0;
  28. long total_time, savedtimerc;
  29.  
  30. /* global variable from mp2init.c */
  31. extern long filepos,block;
  32.  
  33. /* global variables from mp2audio.c */
  34. extern int fd,replay,quit,file_open;
  35. extern long buffer,left;
  36. extern char buffer_mem[(long)BLOCK_SIZE];
  37. extern int acc_id, vdi_id;
  38. extern WINDFORM windforms[5];
  39.  
  40. /* Functions from mp2init.c */
  41. extern void init_replay(void);
  42. extern void continue_replay(void);
  43.  
  44. /* Functions from mp2exit.c */
  45. extern void exit_replay(void);
  46. extern void pause_replay(void);
  47.  
  48. /* Functions from mp2file.c */
  49. extern int open_file(void);
  50. extern int reopen_file(void);
  51. extern void close_file(int fd);
  52. extern void load(int q);
  53.  
  54. /* Function from mp2info.c */
  55. extern int getmp2info(void);
  56.  
  57. #define FG 1
  58. #define BG 0
  59.  
  60. #define max(a,b) ((a)>(b)?(a):(b))
  61. #define min(a,b) ((a)<(b)?(a):(b))
  62.  
  63. typedef struct { int x1,y1,x2,y2; } CORDS2;
  64.  
  65. void main_event_loop()
  66. {
  67.     fgbg=(_app?FG:BG);
  68.     
  69.     while(!quit)
  70.     {
  71.         if(closed_acc)
  72.         {
  73.             evnt_timer(1000,0);
  74. #ifdef DEBUG
  75.             form_alert(1,"[1][ACC reopened][Ok]");
  76. #endif
  77.             fg_init(&windforms[WIND_CTRL]);
  78.             if(file_was_open)
  79.                 fd=reopen_file();
  80.             closed_acc=0;
  81.         }
  82.         if(fgbg==FG)
  83.             fg_event_loop();
  84.         else if(fgbg==BG)
  85.             bg_event_loop();
  86.     }
  87.  
  88. }
  89.  
  90. /* No form window is open */
  91. void bg_event_loop()
  92. {
  93.     int x,y,kstate,key,clicks,event,state;
  94.     int pipe[8];
  95.  
  96.  
  97.  
  98. #ifdef DEBUG
  99.     form_alert(1,"[1][ACC bg][Ok]");
  100. #endif
  101.     do {
  102.         event = evnt_multi( MU_MESAG | MU_TIMER,
  103.                             2, 0x1, 1,
  104.                             0, 0, 0, 0, 0,
  105.                             0, 0, 0, 0, 0,
  106.                             pipe,
  107.                             500, 0,
  108.                             &x, &y, &state, &kstate, &key, &clicks );
  109.  
  110.         if (event & MU_MESAG)
  111.         {
  112.             handle_message(pipe); /* no window to handle */
  113.         }
  114.  
  115.         if (event & MU_TIMER)
  116.             if (replay)
  117.             {
  118.                 load(1);
  119. /*
  120.                 if(total_time<=Supexec(read_timerc)/200)
  121.                     Supexec(reset_timerc);
  122. */
  123.                 update_time();
  124.             }
  125.             
  126.     } while ((fgbg==BG) && !closed_acc);
  127. }
  128.  
  129. /* Form window open */
  130. void fg_event_loop()
  131. {
  132.     int x,y,kstate,key,clicks,event,state;
  133.     int pipe[8];
  134.     int fgexit=0,tmph;
  135.     
  136.     wind_open(windforms[WIND_CTRL].whandle,
  137.         windforms[WIND_CTRL].wind.x,windforms[WIND_CTRL].wind.y,
  138.         windforms[WIND_CTRL].wind.w,windforms[WIND_CTRL].wind.h);
  139.     windforms[WIND_CTRL].wind_open=1;
  140.  
  141. #ifdef DEBUG
  142.     form_alert(1,"[1][ACC fg][Ok]");
  143. #endif
  144.     do {
  145.         event = evnt_multi( MU_MESAG | MU_TIMER | MU_BUTTON,
  146.                             1, 0x3, 0x1,
  147.                             0, 0, 0, 0, 0,
  148.                             0, 0, 0, 0, 0,
  149.                             pipe,
  150.                             500, 0,
  151.                             &x, &y, &state, &kstate, &key, &clicks );
  152.  
  153.         if (event & MU_MESAG)
  154.             fgexit=handle_message(pipe);
  155.  
  156.         if (event & MU_BUTTON)
  157.         {
  158.             if(replay)
  159.                 windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_flags |= KEEPSELECT;
  160.             else
  161.                 windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_flags &= ~KEEPSELECT;
  162.             wind_get(0,WF_TOP,&tmph);
  163.             if(tmph==windforms[WIND_CTRL].whandle)
  164.                 if(ev2_loop(&windforms[WIND_CTRL],x,y))
  165.                     event=0;
  166.         }
  167.  
  168.         if (event & MU_TIMER)
  169.             if (replay)
  170.             {
  171.                 load(1);
  172. /*
  173.                 if(total_time<=Supexec(read_timerc)/200)
  174.                     Supexec(reset_timerc);
  175. */
  176.                 update_time();
  177.             }
  178.         
  179.         if(_app)
  180.             quit=fgexit;
  181.         else
  182.             if(fgexit)
  183.                 fgbg=BG;
  184.  
  185.     } while ((replay || fgbg==FG) && !fgexit);
  186. }
  187.  
  188. int ev2_loop(WINDFORM *wind,int mx,int my)
  189. {
  190.     int x,y,kstate,key,clicks,event,state,org_state;
  191.     int obj_id,ev2exit,fgexit=0;
  192.     int pipe[8];
  193.     CORDS t;
  194.  
  195.  
  196.     if((obj_id=objc_find(wind->formtree,CTRL_FIRST,1,mx,my))>=0)
  197.     {
  198.         if(wind->formtree[obj_id].ob_flags & SELECTABLE)
  199.         {
  200.             org_state=wind->formtree[obj_id].ob_state & SELECTED;
  201.             toggle_object(wind,obj_id);
  202.  
  203.             objc_offset(wind->formtree,obj_id,&t.x,&t.y);
  204.             t.w=wind->formtree[obj_id].ob_width;
  205.             t.h=wind->formtree[obj_id].ob_height;
  206.             ev2exit=0;
  207.             do {
  208.                 event = evnt_multi( MU_MESAG | MU_TIMER | MU_BUTTON | MU_M1 | MU_M2,
  209.                                     1, 0x1, 0x0,
  210.                                     0, t.x, t.y, t.w, t.h,
  211.                                     1, t.x, t.y, t.w, t.h,
  212.                                     pipe,
  213.                                     500, 0,
  214.                                     &x, &y, &state, &kstate, &key, &clicks );
  215.             
  216.  
  217.                 if (event & MU_MESAG)
  218.                     fgexit=handle_message(pipe);
  219.  
  220.                 if (event & MU_M1) /* Enter area */
  221.                 {
  222.                     if(org_state==(wind->formtree[obj_id].ob_state & SELECTED))
  223.                         toggle_object(wind,obj_id);
  224.                 }
  225.                 if (event & MU_M2) /* Leave area */
  226.                 {
  227.                     if(org_state!=(wind->formtree[obj_id].ob_state & SELECTED))
  228.                         toggle_object(wind,obj_id);
  229.                 }
  230.             
  231.                 if (event & MU_BUTTON)
  232.                 {
  233.                     if(obj_id==objc_find(wind->formtree,CTRL_FIRST,1,x,y))
  234.                     {
  235.                         if(wind->formtree[obj_id].ob_flags & KEEPSELECT)
  236.                         {
  237.                             if(org_state && (wind->formtree[obj_id].ob_state & SELECTED))
  238.                             {
  239.                                 objc_change(wind->formtree,obj_id,0,wind->form.x,
  240.                                     wind->form.y,wind->form.w,wind->form.h,NORMAL,1);
  241.                                 wind->formtree[wind->formtree[obj_id].ob_head].ob_x--;
  242.                                 wind->formtree[wind->formtree[obj_id].ob_head].ob_y--;
  243.                                 update_objects(wind,obj_id,1,0);
  244.                             }
  245.                             if(!org_state && !(wind->formtree[obj_id].ob_state & SELECTED))
  246.                             {
  247.                                 objc_change(wind->formtree,obj_id,0,wind->form.x,
  248.                                     wind->form.y,wind->form.w,wind->form.h,SELECTED,1);
  249.                                 wind->formtree[wind->formtree[obj_id].ob_head].ob_x++;
  250.                                 wind->formtree[wind->formtree[obj_id].ob_head].ob_y++;
  251.                                 update_objects(wind,obj_id,1,0);
  252.                             }
  253.                         }
  254.                         else if(wind->formtree[obj_id].ob_state & SELECTED)
  255.                         {
  256.                             objc_change(wind->formtree,obj_id,0,wind->form.x,
  257.                                 wind->form.y,wind->form.w,wind->form.h,NORMAL,1);
  258.                             wind->formtree[wind->formtree[obj_id].ob_head].ob_x--;
  259.                             wind->formtree[wind->formtree[obj_id].ob_head].ob_y--;
  260.                             update_objects(wind,obj_id,1,0);
  261.                         }
  262.                         fgexit=do_formstuff(obj_id);
  263.                     }
  264.                     else
  265.                     {
  266.                         objc_change(wind->formtree,obj_id,0,wind->form.x,
  267.                             wind->form.y,wind->form.w,wind->form.h,org_state,1);
  268.                         update_objects(wind,obj_id,1,0);
  269.                     }
  270.                     ev2exit=1;
  271.                 }
  272.  
  273.         
  274.                 if (event & MU_TIMER)
  275.                     if (replay)
  276.                     {
  277.                         load(1);
  278. /*
  279.                         if(total_time<=Supexec(read_timerc)/200)
  280.                             Supexec(reset_timerc);
  281. */
  282.                         update_time();
  283.                     }
  284.             } while (((replay || fgbg==FG) && !fgexit) && !ev2exit);
  285.             event=0;
  286.             return 1;
  287.         }
  288.     }
  289.     return 0;
  290. }        
  291.  
  292. void toggle_object(WINDFORM *wind,int obj_id)
  293. {
  294.     if(wind->formtree[obj_id].ob_state & SELECTED)
  295.     {
  296.         objc_change(wind->formtree,obj_id,0,wind->form.x,
  297.             wind->form.y,wind->form.w,wind->form.h,
  298.             NORMAL,1);
  299.         wind->formtree[wind->formtree[obj_id].ob_head].ob_x--;
  300.         wind->formtree[wind->formtree[obj_id].ob_head].ob_y--;
  301.     }
  302.     else
  303.     {
  304.         objc_change(wind->formtree,obj_id,0,wind->form.x,
  305.             wind->form.y,wind->form.w,wind->form.h,
  306.             SELECTED,1);
  307.         wind->formtree[wind->formtree[obj_id].ob_head].ob_x++;
  308.         wind->formtree[wind->formtree[obj_id].ob_head].ob_y++;
  309.     }
  310.     update_objects(wind,obj_id,1,0);
  311. }
  312.  
  313. void fg_init(WINDFORM *wind)
  314. {
  315.     form_center(wind->formtree,&wind->form.x,&wind->form.y,
  316.         &wind->form.w,&wind->form.h);
  317.     wind_calc(WC_BORDER,wind->windkind,wind->form.x,wind->form.y,
  318.         wind->form.w,wind->form.h,&wind->wind.x,&wind->wind.y,
  319.         &wind->wind.w,&wind->wind.h);
  320.     wind->whandle=wind_create(wind->windkind,wind->wind.x,wind->wind.y,
  321.         wind->wind.w,wind->wind.h);
  322.     wind_set(wind->whandle,WF_NAME,wind->wind_title);
  323.     wind_calc(WC_WORK,wind->windkind,wind->wind.x,wind->wind.y,
  324.         wind->wind.w,wind->wind.h,&wind->form.x,&wind->form.y,
  325.         &wind->form.w,&wind->form.h);
  326.     wind->formtree[wind->firstobj].ob_x=wind->form.x;
  327.     wind->formtree[wind->firstobj].ob_y=wind->form.y;
  328.     wind->formtree[wind->firstobj].ob_width=wind->form.w;
  329.     wind->formtree[wind->firstobj].ob_height=wind->form.h;
  330. }
  331.  
  332. int handle_message(int pipe[8])
  333. {
  334.     static int first_open=0;
  335.     int wnr;
  336.  
  337. #ifdef DEBUG
  338.     char tmp[128];
  339. #endif
  340.  
  341.     switch (pipe[0]) {
  342.         case AC_OPEN:
  343.             if (pipe[4] == acc_id)
  344.                 if(first_open)
  345.                 {
  346.                     if(windforms[WIND_CTRL].wind_open)
  347.                         wind_set(windforms[WIND_CTRL].whandle,WF_TOP);
  348.                     else
  349.                         fgbg=FG;
  350.                 }
  351.                 else
  352.                 {
  353.                     fg_init(&windforms[WIND_CTRL]);
  354.                     fgbg=FG;
  355.                     first_open=1;
  356.                 }
  357. #ifdef DEBUG
  358.                 form_alert(1,"[1][Got AC_OPEN][Ok]");
  359. #endif
  360.             break;
  361.         case AC_CLOSE:
  362. /*            if (pipe[4] == acc_id) */
  363.  
  364.             {
  365.                 filepos=Fseek(0L,fd,1);
  366. #ifdef DEBUG
  367.                 sprintf(tmp,"[1][Got AC_CLOSE|ACC id: %d|pipe4: %d][Ok]",acc_id,pipe[4]);
  368.                 form_alert(1,tmp);
  369. #endif
  370.  
  371.                 if(windforms[WIND_CTRL].wind_open)
  372.                 {
  373.                     wind_close(windforms[WIND_CTRL].whandle);
  374.                     wind_delete(windforms[WIND_CTRL].whandle);
  375.                     windforms[WIND_CTRL].wind_open=0;
  376.                 }
  377.                 if(windforms[WIND_INFO].wind_open)
  378.                 {
  379.                     wind_close(windforms[WIND_INFO].whandle);
  380.                     wind_delete(windforms[WIND_INFO].whandle);
  381.                     windforms[WIND_INFO].wind_open=0;
  382.                 }
  383. /*
  384.                 if(windforms[WIND_LYRICS].wind_open)
  385.                 {
  386.                     wind_close(windforms[WIND_LYRICS].whandle);
  387.                     wind_delete(windforms[WIND_LYRICS].whandle);
  388.                     windforms[WIND_LYRICS].wind_open=0;
  389.                 }
  390. */
  391. #ifdef DEBUG
  392.                 sprintf(tmp,"[1][Filepos: %ld][Ok]",filepos);
  393.                 form_alert(1,tmp);
  394. #endif
  395.                 file_was_open=file_open;
  396.                 if(file_open)
  397.                     close_file(fd);
  398.                 closed_acc=1;
  399.                 return 1;
  400.             }
  401. /*            break; */
  402.             
  403.         case AP_TERM:
  404. /*            switch(pipe[5])
  405.             {
  406.                 case AP_RESCHG:
  407.                     printf("Got AP_RESCHG!\n");
  408.                 break;
  409.                 case AP_TERM:
  410.                     printf("Got AP_TERM!");
  411.                 break;
  412.                 default:
  413.                     printf("Got unknown AP_TERM!");
  414.             }
  415. */
  416.             break;
  417.         case RESCHG_COMPLETED:
  418. /*            printf("Got RESCHG_COMPLETED!"); */
  419.             break;
  420.         
  421.         case WM_REDRAW:
  422.             if((wnr=find_windform(pipe[3]))>=0)
  423.                 update_objects(&windforms[wnr],windforms[wnr].firstobj,
  424.                     windforms[wnr].objdepth,pipe);
  425.             break;
  426.         case WM_MOVED:
  427.             if((wnr=find_windform(pipe[3]))>=0)
  428.             {
  429.                 wind_set(windforms[wnr].whandle,WF_CURRXYWH,pipe[4],pipe[5],pipe[6],pipe[7]);
  430.                 windforms[wnr].wind.x=pipe[4];
  431.                 windforms[wnr].wind.y=pipe[5];
  432.                 windforms[wnr].wind.w=pipe[6];
  433.                 windforms[wnr].wind.h=pipe[7];
  434.                 wind_calc(WC_WORK,windforms[wnr].windkind,
  435.                     windforms[wnr].wind.x,windforms[wnr].wind.y,
  436.                     windforms[wnr].wind.w,windforms[wnr].wind.h,
  437.                     &windforms[wnr].form.x,&windforms[wnr].form.y,
  438.                     &windforms[wnr].form.w,&windforms[wnr].form.h);
  439.                 windforms[wnr].formtree[windforms[wnr].firstobj].ob_x=windforms[wnr].form.x;
  440.                 windforms[wnr].formtree[windforms[wnr].firstobj].ob_y=windforms[wnr].form.y;
  441.                 windforms[wnr].formtree[windforms[wnr].firstobj].ob_width=windforms[wnr].form.w;
  442.                 windforms[wnr].formtree[windforms[wnr].firstobj].ob_height=windforms[wnr].form.h;
  443.                 if(replay)
  444.                     update_time();
  445.             }
  446.             break;
  447.         case WM_CLOSED:
  448.             if((wnr=find_windform(pipe[3]))>=0)
  449.             {
  450.                 wind_close(windforms[wnr].whandle);
  451.                 windforms[wnr].wind_open=0;
  452.                 if(wnr==WIND_CTRL)
  453.                 {
  454.                     if(windforms[WIND_INFO].wind_open)
  455.                     {
  456.                         wind_close(windforms[WIND_INFO].whandle);
  457.                         windforms[WIND_INFO].wind_open=0;
  458.                     }
  459. /*
  460.                     if(windforms[WIND_LYRICS].wind_open)
  461.                     {
  462.                         wind_close(windforms[WIND_LYRICS].whandle);
  463.                         windforms[WIND_LYRICS].wind_open=0;
  464.                     }
  465. */
  466.                     return 1;
  467.                 }
  468.                 else
  469.                     wind_delete(windforms[wnr].whandle);
  470.             }
  471.             break;
  472.         case WM_TOPPED:
  473.             if((wnr=find_windform(pipe[3]))>=0)
  474.                 wind_set(pipe[3],WF_TOP);
  475.             break;
  476.         default:
  477. #ifdef DEBUG
  478.             sprintf(tmp,"[1][Unimplemented message: %d][Ok]",pipe[0]);
  479.             form_alert(1,tmp);
  480. #endif
  481.             break;
  482.     }
  483.     return 0;
  484. }
  485.  
  486. int find_windform(int whandle)
  487. {
  488.     /* Do this more general later perhaps */
  489.  
  490.     if(whandle==windforms[WIND_CTRL].whandle)
  491.         return WIND_CTRL;
  492.     if(whandle==windforms[WIND_INFO].whandle)
  493.         return WIND_INFO;
  494. /*
  495.     if(whandle==windforms[WIND_LYRICS].whandle)
  496.         return WIND_LYRICS;
  497. */
  498.     return -1;
  499. }
  500.  
  501. void update_objects(WINDFORM *wind,int obj_id,int depth, int pipe[8])
  502. {
  503.     CORDS2 r,u,o;
  504.     CORDS t;
  505.  
  506.     if(pipe)
  507.     {
  508.         o.x1=pipe[4];  o.y1=pipe[5];
  509.         o.x2=pipe[4]+pipe[6]-1;  o.y2=pipe[5]+pipe[7]-1;
  510.     }
  511.  
  512.     graf_mouse(M_OFF,0);
  513.     wind_update(BEG_UPDATE);
  514.     wind_get(wind->whandle,WF_FIRSTXYWH,&t.x,&t.y,&t.w,&t.h);
  515.     while(t.w || t.h)
  516.     {
  517.         if(pipe)
  518.         {
  519.             r.x1=t.x;  r.y1=t.y;
  520.             r.x2=t.x+t.w-1;  r.y2=t.y+t.h-1;
  521.             u.x1=max(r.x1,o.x1);  u.y1=max(r.y1,o.y1);
  522.             u.x2=min(r.x2,o.x2);  u.y2=min(r.y2,o.y2);
  523.         }
  524.         else
  525.         {
  526.             u.x1=t.x;  u.y1=t.y;
  527.             u.x2=t.x+t.w-1;  u.y2=t.y+t.h-1;
  528.         }
  529.         
  530.         if((u.x2>=u.x1) && (u.y2>=u.y1)) 
  531.             objc_draw(wind->formtree,obj_id,depth,
  532.                 u.x1,u.y1,u.x2-u.x1+1,u.y2-u.y1+1);
  533.         wind_get(wind->whandle,WF_NEXTXYWH,&t.x,&t.y,&t.w,&t.h);
  534.     }
  535.     wind_update(END_UPDATE);
  536.     graf_mouse(M_ON,0);
  537. }
  538.  
  539. int do_formstuff(int obj_id)
  540. {
  541.     static int replay_pause=0;
  542.     int tfd;
  543.  
  544.     switch(obj_id)
  545.     {
  546.         case CTRL_STOP:
  547.             if(replay || replay_pause)
  548.             {
  549.                 if(windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_state & SELECTED)
  550.                 {
  551.                     objc_change(windforms[WIND_CTRL].formtree,CTRL_PAUSE,0,
  552.                         windforms[WIND_CTRL].form.x,windforms[WIND_CTRL].form.y,
  553.                         windforms[WIND_CTRL].form.w,windforms[WIND_CTRL].form.h,
  554.                         NORMAL,1);
  555.                     windforms[WIND_CTRL].formtree[windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_head].ob_x--;
  556.                     windforms[WIND_CTRL].formtree[windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_head].ob_y--;
  557.                     update_objects(&windforms[WIND_CTRL],CTRL_PAUSE,1,0);
  558.                 }
  559.                 replay_pause=0;
  560.                 exit_replay();
  561.                 Supexec(reset_timerc);
  562.                 update_time();
  563.             }
  564.             break;
  565.         case CTRL_PLAY:
  566.             if(replay_pause)
  567.             {
  568.                 if(windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_state & SELECTED)
  569.                 {
  570.                     objc_change(windforms[WIND_CTRL].formtree,CTRL_PAUSE,0,
  571.                         windforms[WIND_CTRL].form.x,windforms[WIND_CTRL].form.y,
  572.                         windforms[WIND_CTRL].form.w,windforms[WIND_CTRL].form.h,
  573.                         NORMAL,1);
  574.                     windforms[WIND_CTRL].formtree[windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_head].ob_x--;
  575.                     windforms[WIND_CTRL].formtree[windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_head].ob_y--;
  576.                     update_objects(&windforms[WIND_CTRL],CTRL_PAUSE,1,0);
  577.                 }
  578.                 Supexec(set_timerc);
  579.                 continue_replay();
  580.                 replay_pause=0;
  581.             }
  582.             else
  583.             {
  584.                 if(!replay && file_open)
  585.                 {
  586.                     replay_pause=0;
  587.                     init_replay();
  588.                 }
  589.                 else
  590.                 {
  591.                     if((tfd = open_file()) > 0)
  592.                     {
  593.                         fd=tfd;
  594.                         if(getmp2info())
  595.                         {
  596.                             Fseek(0L,fd,0);
  597.                             replay_pause=0;
  598.                             Supexec(reset_timerc);
  599.                             update_time();
  600.                             init_replay();
  601.                         }
  602.                         else
  603.                         {
  604.                             close_file(fd);
  605.                             strcpy(windforms[WIND_CTRL].wind_title,"MPEG-2");
  606.                             wind_set(windforms[WIND_CTRL].whandle,WF_NAME,
  607.                                 windforms[WIND_CTRL].wind_title);
  608.                         }
  609.     
  610.                     }
  611.                 }
  612.             }
  613.             break;
  614.         case CTRL_PAUSE:
  615.  
  616.             if(replay_pause)
  617.             {
  618.                 Supexec(set_timerc);
  619.                 continue_replay();
  620.                 replay_pause=0;
  621.             }
  622.             else
  623.             {
  624.                 if(replay)
  625.                 {
  626.                     savedtimerc=Supexec(read_timerc);
  627.                     pause_replay();
  628.                     replay_pause=1;
  629.                 }
  630.             }
  631.  
  632.             break;
  633.         case CTRL_LOAD:
  634.             if((tfd = open_file()) > 0)
  635.             {
  636.                 fd=tfd;
  637.                 if(getmp2info())
  638.                 {
  639.                     if(windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_state & SELECTED)
  640.                     {
  641.                         objc_change(windforms[WIND_CTRL].formtree,CTRL_PAUSE,0,
  642.                             windforms[WIND_CTRL].form.x,windforms[WIND_CTRL].form.y,
  643.                             windforms[WIND_CTRL].form.w,windforms[WIND_CTRL].form.h,
  644.                             NORMAL,1);
  645.                         windforms[WIND_CTRL].formtree[windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_head].ob_x--;
  646.                         windforms[WIND_CTRL].formtree[windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_head].ob_y--;
  647.                         update_objects(&windforms[WIND_CTRL],CTRL_PAUSE,1,0);
  648.                     }
  649.                     Fseek(0L,fd,0);
  650.                     replay_pause=0;
  651.                     Supexec(reset_timerc);
  652.                     update_time();
  653.                 }
  654.                 else
  655.                 {
  656.                     if(windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_state & SELECTED)
  657.                     {
  658.                         objc_change(windforms[WIND_CTRL].formtree,CTRL_PAUSE,0,
  659.                             windforms[WIND_CTRL].form.x,windforms[WIND_CTRL].form.y,
  660.                             windforms[WIND_CTRL].form.w,windforms[WIND_CTRL].form.h,
  661.                             NORMAL,1);
  662.                         windforms[WIND_CTRL].formtree[windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_head].ob_x--;
  663.                         windforms[WIND_CTRL].formtree[windforms[WIND_CTRL].formtree[CTRL_PAUSE].ob_head].ob_y--;
  664.                         update_objects(&windforms[WIND_CTRL],CTRL_PAUSE,1,0);
  665.                     }
  666.                     close_file(fd);
  667.                     replay_pause=0;
  668.                     strcpy(windforms[WIND_CTRL].wind_title,"MPEG");
  669.                     wind_set(windforms[WIND_CTRL].whandle,WF_NAME,
  670.                         windforms[WIND_CTRL].wind_title);
  671.                 }
  672.             }
  673.             break;
  674.         case CTRL_LOOP:
  675.             looping=(windforms[WIND_CTRL].formtree[CTRL_LOOP].ob_state & SELECTED);
  676.             break;
  677.         case CTRL_INFO:
  678.             /* Open info window */
  679.             if(windforms[WIND_INFO].wind_open)
  680.                 wind_set(windforms[WIND_INFO].whandle,WF_TOP);
  681.             else
  682.             {
  683.                 fg_init(&windforms[WIND_INFO]);
  684.                 wind_open(windforms[WIND_INFO].whandle,
  685.                     windforms[WIND_INFO].wind.x,windforms[WIND_INFO].wind.y,
  686.                     windforms[WIND_INFO].wind.w,windforms[WIND_INFO].wind.h);
  687.                 windforms[WIND_INFO].wind_open=1;
  688.             }
  689.             break;
  690.         case CTRL_LYRICS:
  691.             /* Open lyrics window */
  692.             break;
  693.         default:
  694.             break;
  695.     }
  696.     return 0;
  697. }
  698.  
  699.  
  700. long reset_timerc()
  701. {
  702.     *((long *)0x4baL)=0L;
  703.     return 0;
  704. }
  705. long read_timerc()
  706. {
  707.     return *((long *)0x4baL);
  708. }
  709. long set_timerc()
  710. {
  711.     *((long *)0x4baL)=savedtimerc;
  712.     return 0;
  713. }
  714.  
  715. void update_time()
  716. {
  717.     long time_elap;
  718.     char tmp[64];
  719.     
  720.     time_elap=total_time-Supexec(read_timerc)/200;
  721.     
  722.     sprintf(tmp,"%02ld:%02ld",time_elap/60,time_elap%60);
  723.     if(strcmp(tmp,windforms[WIND_CTRL].wind_title))
  724.     {
  725.         strcpy(windforms[WIND_CTRL].wind_title,tmp);
  726.         wind_set(windforms[WIND_CTRL].whandle,WF_NAME,
  727.             windforms[WIND_CTRL].wind_title);
  728.     }
  729. }
  730.